/*******************************************************************************
 * Copyright (c) 2000, 2015 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.ui.part;

import org.eclipse.jface.action.ICoolBarManager;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.IStatusLineManager;
import org.eclipse.jface.action.IToolBarManager;
import org.eclipse.ui.IActionBars;
import org.eclipse.ui.IActionBars2;
import org.eclipse.ui.IEditorActionBarContributor;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IWorkbenchPage;

/**
 * Standard implementation of <code>IEditorActionBarContributor</code>.
 * <p>
 * If instantiated and used as-is, nothing is contribututed. Clients should
 * subclass in order to contribute to some or all of the action bars.
 * <p>
 * Subclasses may reimplement the following methods:
 * <ul>
 *   <li><code>contributeToMenu</code> - reimplement to contribute to menu</li>
 *   <li><code>contributeToToolBar</code> - reimplement to contribute to tool
 *     bar</li>
 *   <li><code>contributeToStatusLine</code> - reimplement to contribute to
 *     status line</li>
 *   <li><code>setActiveEditor</code> - reimplement to react to editor changes</li>
 * </ul>
 * </p>
 */
public class EditorActionBarContributor implements IEditorActionBarContributor {
    /**
     * The action bars; <code>null</code> until <code>init</code> is called.
     */
    private IActionBars bars;

    /**
     * The workbench page; <code>null</code> until <code>init</code> is called.
     */
    private IWorkbenchPage page;

    /**
     * Creates an empty editor action bar contributor. The action bars are
     * furnished later via the <code>init</code> method.
     */
    public EditorActionBarContributor() {
    }

    /**
     * Contributes to the given menu.
     * <p>
     * The <code>EditorActionBarContributor</code> implementation of this method
     * does nothing. Subclasses may reimplement to add to the menu portion of this
     * contribution.
     * </p>
     *
     * @param menuManager the manager that controls the menu
     */
    public void contributeToMenu(IMenuManager menuManager) {
    }

    /**
     * Contributes to the given status line.
     * <p>
     * The <code>EditorActionBarContributor</code> implementation of this method
     * does nothing. Subclasses may reimplement to add to the status line portion of
     * this contribution.
     * </p>
     *
     * @param statusLineManager the manager of the status line
     */
    public void contributeToStatusLine(IStatusLineManager statusLineManager) {
    }

    /**
     * Contributes to the given tool bar.
     * <p>
     * The <code>EditorActionBarContributor</code> implementation of this method
     * does nothing. Subclasses may reimplement to add to the tool bar portion of
     * this contribution.
     * </p>
     *
     * @param toolBarManager the manager that controls the workbench tool bar
     */
    public void contributeToToolBar(IToolBarManager toolBarManager) {
    }

    /**
     * Contributes to the given cool bar.
     * <p>
     * The <code>EditorActionBarContributor</code> implementation of this method
     * does nothing. Subclasses may reimplement to add to the cool bar portion of
     * this contribution. There can only be contributions from a cool bar or a tool bar.
     * </p>
     *
     * @param coolBarManager the manager that controls the workbench cool bar.
     *
     * @since 3.0
     */
    public void contributeToCoolBar(ICoolBarManager coolBarManager) {
    }

    /**
     * Returns this contributor's action bars.
     *
     * @return the action bars
     */
    public IActionBars getActionBars() {
        return bars;
    }

    /**
     * Returns this contributor's workbench page.
     *
     * @return the workbench page
     */
    public IWorkbenchPage getPage() {
        return page;
    }

    /**
     * The <code>EditorActionBarContributor</code> implementation of this
     * <code>IEditorActionBarContributor</code> method does nothing,
     * subclasses may override.
     */
    @Override
	public void dispose() {
    }

    /**
     * The <code>EditorActionBarContributor</code> implementation of this
     * <code>IEditorActionBarContributor</code> method remembers the page
     * then forwards the call to <code>init(IActionBars)</code> for
     * backward compatibility
     */
    @Override
	public void init(IActionBars bars, IWorkbenchPage page) {
        this.page = page;
        init(bars);
    }

    /**
     * This method calls:
     * <ul>
     *  <li><code>contributeToMenu</code> with <code>bars</code>' menu manager</li>
     *  <li><code>contributeToToolBar</code> with <code>bars</code>' tool bar
     *    manager</li>
     *  <li><code>contributeToCoolBar</code> with <code>bars</code>' cool bar
     *    manager if <code>IActionBars</code> is of extended type <code>IActionBars2</code> </li>
     *  <li><code>contributeToStatusLine</code> with <code>bars</code>' status line
     *    manager</li>
     * </ul>
     * The given action bars are also remembered and made accessible via
     * <code>getActionBars</code>.
     *
     * @param bars the action bars
     */
    public void init(IActionBars bars) {
        this.bars = bars;
        contributeToMenu(bars.getMenuManager());
        contributeToToolBar(bars.getToolBarManager());
        if (bars instanceof IActionBars2) {
            contributeToCoolBar(((IActionBars2) bars).getCoolBarManager());
        }
        contributeToStatusLine(bars.getStatusLineManager());

    }

    /**
     * Sets the active editor for the contributor.
     * <p>
     * The <code>EditorActionBarContributor</code> implementation of this method does
     * nothing. Subclasses may reimplement. This generally entails disconnecting
     * from the old editor, connecting to the new editor, and updating the actions
     * to reflect the new editor.
     * </p>
     *
     * @param targetEditor the new target editor
     */
    @Override
	public void setActiveEditor(IEditorPart targetEditor) {
    }
}
